home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / dalla rivista / host contacted / jikes.lha / jikes-1.11 / src / double.cpp < prev    next >
C/C++ Source or Header  |  2000-01-06  |  9KB  |  345 lines
  1. // $Id: double.cpp,v 1.9 2000/01/06 07:47:24 lord Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include <iostream.h>
  12. #include "double.h"
  13. #include "long.h"
  14.  
  15. IEEEfloat::IEEEfloat(float d)
  16. {
  17.     value.float_value = d;
  18. }
  19.  
  20. IEEEfloat::IEEEfloat(u4 a)
  21. {
  22.     value.word = a;
  23. }
  24.  
  25. IEEEfloat::IEEEfloat(i4 a)
  26. {
  27.     value.float_value = a;
  28. }
  29.  
  30. IEEEfloat::IEEEfloat(char *name)
  31. {
  32.     //
  33.     // TODO: This conversion is a temporary patch. Need volunteer to implement
  34.     //       Clinger algorithm from PLDI 1990.
  35.     //
  36.     value.float_value = atof(name);
  37. }
  38.  
  39. float IEEEfloat::FloatRoundedValue()
  40. {
  41.     //
  42.     // TODO: Implement this properly !
  43.     //
  44.     return value.float_value;
  45. }
  46.  
  47. bool IEEEfloat::operator== (IEEEfloat op)
  48. {
  49.     return value.float_value == op.value.float_value;
  50. }
  51.  
  52. bool IEEEfloat::operator!= (IEEEfloat op)
  53. {
  54.     return value.float_value != op.value.float_value;
  55. }
  56.  
  57.  
  58. bool IEEEfloat::operator< (IEEEfloat op)
  59. {
  60.     return (value.float_value < op.value.float_value ? true : false);
  61. }
  62.  
  63. bool IEEEfloat::operator<= (IEEEfloat op)
  64. {
  65.     return (value.float_value <= op.value.float_value ? true : false);
  66. }
  67.  
  68. bool IEEEfloat::operator> (IEEEfloat op)
  69. {
  70.     return (value.float_value > op.value.float_value ? true : false);
  71. }
  72.  
  73. bool IEEEfloat::operator>= (IEEEfloat op)
  74. {
  75.     return (value.float_value >= op.value.float_value ? true : false);
  76. }
  77.  
  78. IEEEfloat IEEEfloat::operator+ (IEEEfloat op)
  79. {
  80.     return IEEEfloat(value.float_value + op.value.float_value);
  81. }
  82.  
  83. IEEEfloat& IEEEfloat::operator+= (IEEEfloat op)
  84. {
  85.     *this = *this + op;
  86.     return *this;
  87. }
  88.  
  89.  
  90. IEEEfloat IEEEfloat::operator- ()
  91. {
  92.     return IEEEfloat((0x80000000 & value.word) == 0x80000000 ? 0x7fffffff & value.word : 0x80000000 | value.word);
  93. }
  94.  
  95. IEEEfloat IEEEfloat::operator- (IEEEfloat op)
  96. {
  97.     return *this + (-op);
  98. }
  99.  
  100. IEEEfloat& IEEEfloat::operator-= (IEEEfloat op)
  101. {
  102.     *this = *this - op;
  103.     return *this;
  104. }
  105.  
  106. IEEEfloat IEEEfloat::operator* (IEEEfloat op)
  107. {
  108.     return IEEEfloat(value.float_value * op.value.float_value);
  109. }
  110.  
  111. IEEEfloat& IEEEfloat::operator*= (IEEEfloat op)
  112. {
  113.     *this = *this * op;
  114.     return *this;
  115. }
  116.  
  117. IEEEfloat IEEEfloat::operator/ (IEEEfloat op)
  118. {
  119. #ifndef IEEE_DIV_0
  120.     return IEEEfloat(value.float_value / op.value.float_value);
  121. #else /* IEEE_DIV_0 */
  122.     return (op.value.float_value == 0.0
  123.                                   ? (value.float_value < 0.0
  124.                                                        ? NEGATIVE_INFINITY()
  125.                                                        : (value.float_value == 0.0
  126.                                                                             ? NaN()
  127.                                                                             : POSITIVE_INFINITY()))
  128.                                   : IEEEfloat(value.float_value / op.value.float_value));
  129. #endif /* IEEE_DIV_0 */
  130. }
  131.  
  132. IEEEfloat& IEEEfloat::operator/= (IEEEfloat op)
  133. {
  134. #ifndef IEEE_DIV_0
  135.     *this = *this / op;
  136. #else /* IEEE_DIV_0 */
  137.     *this = (op.value.float_value == 0.0
  138.                                    ? (IEEEfloat) (*this < (float) 0.0
  139.                                             ? NEGATIVE_INFINITY()
  140.                                             : *this == (float) 0.0
  141.                                                      ? NaN()
  142.                                                      : POSITIVE_INFINITY())
  143.                                    : *this / op);
  144. #endif /* IEEE_DIV_0 */
  145.  
  146.     return *this;
  147. }
  148.  
  149. IEEEfloat::IEEEfloat(IEEEdouble a)
  150. {
  151.     value.float_value = a.DoubleValue();
  152. }
  153.  
  154. void IEEEfloat::Fmodulus(IEEEfloat a, IEEEfloat b, IEEEfloat& result)
  155. {
  156. #ifndef IEEE_DIV_0
  157.     result.value.float_value = (float) fmod((double) a.value.float_value, (double) b.value.float_value);
  158. #else /* IEEE_DIV_0 */
  159.     result.value.float_value = (b.value.float_value == 0.0 ? NaN().FloatValue()
  160.                                                            : fmod((double) a.value.float_value, (double) b.value.float_value));
  161. #endif /* IEEE_DIV_0 */
  162.  
  163.     return;
  164. }
  165.  
  166. IEEEdouble IEEEdouble::min_long = IEEEdouble(0xc3e00000, 0x00000000);
  167.  
  168. double IEEEdouble::DoubleRoundedValue()
  169. {
  170.     //
  171.     // TODO: Implement this properly !
  172.     //
  173.     return DoubleValue();
  174. }
  175.  
  176. IEEEdouble::IEEEdouble(double d)
  177. {
  178.     value.double_value = d;
  179. }
  180.  
  181. IEEEdouble::IEEEdouble(u4 a, u4 b)
  182. {
  183.     High() = a;
  184.     Low() = b;
  185. }
  186.  
  187. IEEEdouble::IEEEdouble(IEEEfloat a)
  188. {
  189.     value.double_value = a.FloatValue();
  190. }
  191.  
  192. IEEEdouble::IEEEdouble(i4 a)
  193. {
  194.     value.double_value = a;
  195. }
  196.  
  197. IEEEdouble::IEEEdouble(u4 a)
  198. {
  199.     High() = 0;
  200.     Low() = a;
  201. }
  202.  
  203. IEEEdouble::IEEEdouble(char *name)
  204. {
  205.     //
  206.     // TODO: This conversion is a temporary patch. Need volunteer to implement
  207.     //       Clinger algorithm from PLDI 1990.
  208.     //
  209.     value.double_value = atof(name);
  210. }
  211.  
  212. bool IEEEdouble::operator== (IEEEdouble op)
  213. {
  214.     return value.double_value == op.value.double_value;
  215. }
  216.  
  217. bool IEEEdouble::operator!= (IEEEdouble op)
  218. {
  219.     return value.double_value != op.value.double_value;
  220. }
  221.  
  222. IEEEdouble IEEEdouble::operator+ (IEEEdouble op)
  223. {
  224.     return IEEEdouble(value.double_value + op.value.double_value);
  225. }
  226.  
  227. IEEEdouble& IEEEdouble::operator+= (IEEEdouble op)
  228. {
  229.     *this = *this + op;
  230.     return *this;
  231. }
  232.  
  233. IEEEdouble IEEEdouble::operator- ()
  234. {
  235.     u4 high = this -> HighWord();
  236.     return IEEEdouble(((0x80000000 & high) == 0x80000000 ? 0x7fffffff & high : 0x80000000 | high), this -> LowWord());
  237. }
  238.  
  239. IEEEdouble IEEEdouble::operator- (IEEEdouble op)
  240. {
  241.     return IEEEdouble(value.double_value + (-op.value.double_value));
  242. }
  243.  
  244. IEEEdouble& IEEEdouble::operator-= (IEEEdouble op)
  245. {
  246.     *this = *this - op;
  247.     return *this;
  248. }
  249.  
  250.  
  251. IEEEdouble IEEEdouble::operator* (IEEEdouble op)
  252. {
  253.     return IEEEdouble(value.double_value * op.value.double_value);
  254. }
  255.  
  256. IEEEdouble& IEEEdouble::operator*= (IEEEdouble op)
  257. {
  258.     *this = *this * op;
  259.     return *this;
  260. }
  261.  
  262. IEEEdouble IEEEdouble::operator/ (IEEEdouble op)
  263. {
  264. #ifndef IEEE_DIV_0
  265.     return IEEEdouble(value.double_value / op.value.double_value);
  266. #else /* IEEE_DIV_0 */
  267.     return (op.value.double_value == 0.0
  268.                                    ? (value.double_value < 0.0
  269.                                                          ? NEGATIVE_INFINITY()
  270.                                                          : value.double_value == 0.0
  271.                                                                                ? NaN()
  272.                                                                                : POSITIVE_INFINITY())
  273.                                    : IEEEdouble(value.double_value / op.value.double_value));
  274. #endif /* IEEE_DIV_0 */
  275. }
  276.  
  277. IEEEdouble& IEEEdouble::operator/= (IEEEdouble op)
  278. {
  279. #ifndef IEEE_DIV_0
  280.     *this = *this / op;
  281. #else /* IEEE_DIV_0 */
  282.     *this = (op.value.double_value == 0.0
  283.                                     ? (*this < 0.0
  284.                                              ? NEGATIVE_INFINITY()
  285.                                              : *this == 0.0
  286.                                                       ? NaN()
  287.                                                       : POSITIVE_INFINITY())
  288.                                     : *this / op);
  289. #endif /* IEEE_DIV_0 */
  290.  
  291.     return *this;
  292. }
  293.  
  294. bool IEEEdouble::operator< (IEEEdouble op)
  295. {
  296.     return (value.double_value < op.value.double_value ? true : false);
  297. }
  298.  
  299. bool IEEEdouble::operator<= (IEEEdouble op)
  300. {
  301.     return (value.double_value <= op.value.double_value ? true : false);
  302. }
  303.  
  304. bool IEEEdouble::operator> (IEEEdouble op)
  305. {
  306.     return (value.double_value > op.value.double_value ? true : false);
  307. }
  308.  
  309. bool IEEEdouble::operator>= (IEEEdouble op)
  310. {
  311.     return (value.double_value >= op.value.double_value ? true : false);
  312. }
  313.  
  314. void IEEEdouble::Fmodulus(IEEEdouble a, IEEEdouble b, IEEEdouble& result)
  315. {
  316. #ifndef IEEE_DIV_0
  317.      result.value.double_value = fmod(a.value.double_value, b.value.double_value);
  318. #else /* IEEE_DIV_0 */
  319.     result.value.double_value = (b.value.double_value == 0 ? NaN().value.double_value
  320.                                                  : fmod(a.value.double_value, b.value.double_value));
  321. #endif /* IEEE_DIV_0 */
  322. }
  323.  
  324. void IEEEdouble::Divide(IEEEdouble dividend, IEEEdouble divisor, IEEEdouble "ient)
  325. {
  326. #ifndef IEEE_DIV_0
  327.     quotient = dividend.value.double_value / divisor.value.double_value;
  328. #else /* IEEE_DIV_0 */
  329.     quotient = (divisor.value.double_value == 0.0
  330.                                             ? (dividend.value.double_value < 0.0
  331.                                                                            ? NEGATIVE_INFINITY()
  332.                                                                            : dividend.value.double_value == 0.0
  333.                                                                                                           ? NaN()
  334.                                                                                                           : POSITIVE_INFINITY())
  335.                                             : IEEEdouble(dividend.value.double_value / divisor.value.double_value));
  336. #endif /* IEEE_DIV_0 */
  337.  
  338.     return;
  339. }
  340.  
  341. IEEEdouble::IEEEdouble(LongInt& a)
  342. {
  343.     value.double_value = a.Double();
  344. }
  345.